import {_import, _importAttr} from "../store/modules/permission";

/**
 * 日期格式化
 * @param fmt
 * @param date
 * @returns {*}
 */
export function formatDate(fmt, date) {
  let myDate = date ? new Date(date) : new Date()

  fmt = fmt || 'yyyy-MM-dd'
  const o = {
    'M+': myDate.getMonth() + 1, // 月份
    'd+': myDate.getDate(), // 日
    'h+': myDate.getHours(), // 小时
    'm+': myDate.getMinutes(), // 分
    's+': myDate.getSeconds(), // 秒
    'q+': Math.floor((myDate.getMonth() + 3) / 3), // 季度
    'S': myDate.getMilliseconds() // 毫秒
  }
  if (/(y+)/.test(fmt)) {
    fmt = fmt.replace(RegExp.$1, (myDate.getFullYear() + '').substr(4 - RegExp.$1.length))
  }
  for (const k in o) {
    if (new RegExp('(' + k + ')').test(fmt)) {
      fmt = fmt.replace(RegExp.$1, (RegExp.$1.length == 1) ? (o[k]) : (('00' + o[k]).substr(('' + o[k]).length)))
    }
  }
  return fmt
}

/**
 * 防抖函数
 * @param {Function} func
 * @param {number} wait
 * @param {boolean} immediate
 * @return {*}
 */
export function debounce(func, wait, immediate) {
  let timeout, args, context, timestamp, result

  const later = function () {
    // 据上一次触发时间间隔
    const last = +new Date() - timestamp

    // 上次被包装函数被调用时间间隔 last 小于设定时间间隔 wait
    if (last < wait && last > 0) {
      timeout = setTimeout(later, wait - last)
    } else {
      timeout = null
      // 如果设定为immediate===true，因为开始边界已经调用过了此处无需调用
      if (!immediate) {
        result = func.apply(context, args)
        if (!timeout) context = args = null
      }
    }
  }

  return function (...args) {
    context = this
    timestamp = +new Date()
    const callNow = immediate && !timeout
    // 如果延时不存在，重新设定延时
    if (!timeout) timeout = setTimeout(later, wait)
    if (callNow) {
      result = func.apply(context, args)
      context = args = null
    }

    return result
  }
}

/**
 * 节流函数
 * *options的默认值
 *  表示首次调用返回值方法时，会马上调用func；否则仅会记录当前时刻，当第二次调用的时间间隔超过wait时，才调用func。
 *  options.leading = true;
 * 表示当调用方法时，未到达wait指定的时间间隔，则启动计时器延迟调用func函数，若后续在既未达到wait指定的时间间隔和func函数又未被调用的情况下调用返回值方法，则被调用请求将被丢弃。
 *  options.trailing = true;
 * 注意：当options.trailing = false时，效果与上面的简单实现效果相同
 * @param func
 * @param wait
 * @param options
 * @returns {function(): *}
 */
export function throttle(func, wait, options) {
  let time, context, args, result
  let previous = 0
  if (!options) options = {}

  let later = function () {
    previous = options.leading === false ? 0 : new Date().getTime()
    time = null
    func.apply(context, args)
    if (!time) context = args = null
  }

  let throttled = function () {
    let now = new Date().getTime()
    if (!previous && options.leading === false) previous = now
    let remaining = wait - (now - previous)
    context = this
    args = arguments
    if (remaining <= 0 || remaining > wait) {
      if (time) {
        clearTimeout(time)
        time = null
      }
      previous = now
      func.apply(context, args)
      if (!time) context = args = null
    } else if (!time && options.trailing !== false) {
      time = setTimeout(later, remaining)
    }
  }
  return throttled
}


/**
 * 数据分组
 * @param data
 * @param key
 * @returns {{}}
 */
export function arrayGroup(data, key) {
  let groups = {};
  data.forEach(c => {
    let value = c[key];
    groups[value] = groups[value] || [];
    groups[value].push(c);
  });
  return groups;
}

/**
 * 区间随机数
 * @param max
 * @param min
 * @returns {*}
 */
export function sectionRandom(min, max) {
  return (Math.random() * (max - min) + min)
}

/**
 * 多级菜单数组精简 （cookie）
 * @param arrs
 * @param level
 */
export function arrCut(arrs, level = 1) {
  return arrs.map(menu => {
    let item = {
      id: menu.id,
      menuUrl: menu.menuUrl,
      menuComponet: menu.menuComponet,
      menuName: menu.menuName,
      name: menu.routerName,
      hidden: parseInt(menu.menuStatus) === 2,
    }
    if (level === 2 && !item.hidden) {
      item.aside = 'comp/CompAside'
    }else if(level === 3){
      item.aside = 'comp/CompAside'
    }

    if (menu.menuIcon) {
      item.menuIcon = menu.menuIcon
    }
    if (menu.menuCss) {
      item.menuCss = menu.menuCss
    }
    if (menu.child && menu.child.length) {
      item.child = arrCut(menu.child, level + 1)
    }
    return item
  })
}

/**
 * 多级菜单数组过滤
 * @param arrs
 */
export function arrFilter(arrs) {
  return arrs.filter(menu => {
    if (menu.child && menu.child.length) {
      menu.child = arrFilter(menu.child)
    } else {
      delete menu.child
    }
    return menu.menuUrl
  })
}

/***
 * 新增编辑菜单是过滤掉菜单
 * @param arrs
 * @param id
 * @returns {*}
 */
export function menuFilter(arrs, id) {
  return arrs.filter(menu => {
    if (menu.children && menu.children.length) {
      menu.children = menuFilter(menu.children, id)
    }
    return menu.id !== id
  })
}